home *** CD-ROM | disk | FTP | other *** search
/ The Utilities Experience / The Utilities Experience - Volume 1.iso / software / misc / o-z / x-windows / mesa-amiwin / src / enable.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-30  |  13.6 KB  |  531 lines
  1. /* enable.c */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  1.2
  6.  * Copyright (C) 1995  Brian Paul  (brianp@ssec.wisc.edu)
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25. $Id: enable.c,v 1.20 1995/11/01 21:45:45 brianp Exp $
  26.  
  27. $Log: enable.c,v $
  28.  * Revision 1.20  1995/11/01  21:45:45  brianp
  29.  * update CC.Light.LastEnabled when enabling/disabling lights
  30.  *
  31.  * Revision 1.19  1995/10/27  20:29:02  brianp
  32.  * added glPolygonOffsetEXT() support
  33.  *
  34.  * Revision 1.18  1995/10/19  15:47:26  brianp
  35.  * only set NewState flag when really needed
  36.  *
  37.  * Revision 1.17  1995/10/14  16:30:49  brianp
  38.  * added DD.dither call
  39.  *
  40.  * Revision 1.16  1995/10/04  22:02:38  brianp
  41.  * set CC.NewState when GL_LIGHTING is enabled/disabled
  42.  *
  43.  * Revision 1.15  1995/09/22  21:49:52  brianp
  44.  * don't allow glEnable(GL_TEXTURE_xD) in CI mode
  45.  *
  46.  * Revision 1.14  1995/09/15  18:40:25  brianp
  47.  * only signal CC.NewState when necessary
  48.  *
  49.  * Revision 1.13  1995/08/31  21:29:53  brianp
  50.  * new TexGenEnabled bitfield
  51.  * introduced CC.NewState convention
  52.  *
  53.  * Revision 1.12  1995/06/21  15:10:47  brianp
  54.  * allocate stencil buffer when stencil test is enabled
  55.  *
  56.  * Revision 1.11  1995/06/20  22:11:18  brianp
  57.  * fixed depth buffer allocation bug in glEnable(), per Asif Khan
  58.  *
  59.  * Revision 1.10  1995/05/22  21:02:41  brianp
  60.  * Release 1.2
  61.  *
  62.  * Revision 1.9  1995/05/12  19:26:43  brianp
  63.  * replaced CC.Mode!=0 with INSIDE_BEGIN_END
  64.  *
  65.  * Revision 1.8  1995/03/27  20:31:26  brianp
  66.  * new Texture.Enabled scheme
  67.  *
  68.  * Revision 1.7  1995/03/24  20:03:21  brianp
  69.  * added gl_update_pixel_logic call to GL_BLEND case
  70.  *
  71.  * Revision 1.6  1995/03/24  17:00:22  brianp
  72.  * added gl_update_pixel_logic
  73.  *
  74.  * Revision 1.5  1995/03/09  21:41:39  brianp
  75.  * call gl_udpate_rasterflags for GL_CULL_FACE
  76.  *
  77.  * Revision 1.4  1995/03/09  19:07:39  brianp
  78.  * removed gl_disable, fixed color_material bug
  79.  *
  80.  * Revision 1.3  1995/03/04  19:29:44  brianp
  81.  * 1.1 beta revision
  82.  *
  83.  * Revision 1.2  1995/02/24  15:25:46  brianp
  84.  * added error checks to gl_enable and gl_disable
  85.  *
  86.  * Revision 1.1  1995/02/24  14:21:54  brianp
  87.  * Initial revision
  88.  *
  89.  */
  90.  
  91.  
  92. #include <string.h>
  93. #include "context.h"
  94. #include "dd.h"
  95. #include "depth.h"
  96. #include "draw.h"
  97. #include "list.h"
  98. #include "macros.h"
  99. #include "stencil.h"
  100.  
  101.  
  102.  
  103.  
  104. /*
  105.  * Perform glEnable and glDisable calls.
  106.  */
  107. void gl_enable( GLenum cap, GLboolean state )
  108. {
  109.    GLuint i, p;
  110.  
  111.    if (INSIDE_BEGIN_END) {
  112.       if (state) {
  113.      gl_error( GL_INVALID_OPERATION, "glEnable" );
  114.       }
  115.       else {
  116.      gl_error( GL_INVALID_OPERATION, "glDisable" );
  117.       }
  118.       return;
  119.    }
  120.  
  121.    switch (cap) {
  122.       case GL_ALPHA_TEST:
  123.          if (CC.Color.AlphaEnabled!=state) {
  124.             CC.Color.AlphaEnabled = state;
  125.             CC.NewState = GL_TRUE;
  126.          }
  127.      break;
  128.       case GL_AUTO_NORMAL:
  129.      CC.Eval.AutoNormal = state;
  130.      break;
  131.       case GL_BLEND:
  132.          if (CC.Color.BlendEnabled!=state) {
  133.             CC.Color.BlendEnabled = state;
  134.             CC.NewState = GL_TRUE;
  135.          }
  136.      break;
  137.       case GL_CLIP_PLANE0:
  138.       case GL_CLIP_PLANE1:
  139.       case GL_CLIP_PLANE2:
  140.       case GL_CLIP_PLANE3:
  141.       case GL_CLIP_PLANE4:
  142.       case GL_CLIP_PLANE5:
  143.      CC.Transform.ClipEnabled[cap-GL_CLIP_PLANE0] = state;
  144.      /* Check if any clip planes enabled */
  145.          CC.Transform.AnyClip = GL_FALSE;
  146.          for (p=0;p<MAX_CLIP_PLANES;p++) {
  147.             if (CC.Transform.ClipEnabled[p]) {
  148.                CC.Transform.AnyClip = GL_TRUE;
  149.                break;
  150.             }
  151.          }
  152.      break;
  153.       case GL_COLOR_MATERIAL:
  154.      CC.Light.ColorMaterialEnabled = state;
  155.      if (state) {
  156.         gl_color( CC.Current.Color );
  157.      }
  158.      break;
  159.       case GL_CULL_FACE:
  160.          if (CC.Polygon.CullFlag!=state) {
  161.             CC.Polygon.CullFlag = state;
  162.             CC.NewState = GL_TRUE;
  163.          }
  164.      break;
  165.       case GL_DEPTH_TEST:
  166.      if (CC.Depth.Test!=state) {
  167.             CC.Depth.Test = state;
  168.             CC.NewState = GL_TRUE;
  169.          }
  170.      if (state && !CC.DepthBuffer) {
  171.         /* need to allocate a depth buffer now */
  172.         gl_alloc_depth_buffer();
  173.      }
  174.          break;
  175.       case GL_DITHER:
  176.      CC.Color.DitherFlag = state;
  177.          (*DD.dither)( state );
  178.      break;
  179.       case GL_FOG:
  180.      if (CC.Fog.Enabled!=state) {
  181.             CC.Fog.Enabled = state;
  182.             CC.NewState = GL_TRUE;
  183.          }
  184.      break;
  185.       case GL_LIGHT0:
  186.       case GL_LIGHT1:
  187.       case GL_LIGHT2:
  188.       case GL_LIGHT3:
  189.       case GL_LIGHT4:
  190.       case GL_LIGHT5:
  191.       case GL_LIGHT6:
  192.       case GL_LIGHT7:
  193.          CC.Light.Light[cap-GL_LIGHT0].Enabled = state;
  194.          CC.Light.LastEnabled = -1;
  195.          for (i=0;i<MAX_LIGHTS;i++) {
  196.             if (CC.Light.Light[i].Enabled) {
  197.                CC.Light.LastEnabled = i;
  198.             }
  199.          }
  200.          break;
  201.       case GL_LIGHTING:
  202.          if (CC.Light.Enabled!=state) {
  203.             CC.Light.Enabled = state;
  204.             CC.NewState = GL_TRUE;
  205.          }
  206.          break;
  207.       case GL_LINE_SMOOTH:
  208.      if (CC.Line.SmoothFlag!=state) {
  209.             CC.Line.SmoothFlag = state;
  210.             CC.NewState = GL_TRUE;
  211.          }
  212.      break;
  213.       case GL_LINE_STIPPLE:
  214.      if (CC.Line.StippleFlag!=state) {
  215.             CC.Line.StippleFlag = state;
  216.             CC.NewState = GL_TRUE;
  217.          }
  218.      break;
  219.       case GL_LOGIC_OP:
  220.      if (CC.Color.LogicOpEnabled!=state) {
  221.             CC.NewState = GL_TRUE;
  222.          }
  223.      CC.Color.LogicOpEnabled = state;
  224.      break;
  225.       case GL_MAP1_COLOR_4:
  226.      CC.Eval.Map1Color4 = state;
  227.      break;
  228.       case GL_MAP1_INDEX:
  229.      CC.Eval.Map1Index = state;
  230.      break;
  231.       case GL_MAP1_NORMAL:
  232.      CC.Eval.Map1Normal = state;
  233.      break;
  234.       case GL_MAP1_TEXTURE_COORD_1:
  235.      CC.Eval.Map1TextureCoord1 = state;
  236.      break;
  237.       case GL_MAP1_TEXTURE_COORD_2:
  238.      CC.Eval.Map1TextureCoord2 = state;
  239.      break;
  240.       case GL_MAP1_TEXTURE_COORD_3:
  241.      CC.Eval.Map1TextureCoord3 = state;
  242.      break;
  243.       case GL_MAP1_TEXTURE_COORD_4:
  244.      CC.Eval.Map1TextureCoord4 = state;
  245.      break;
  246.       case GL_MAP1_VERTEX_3:
  247.      CC.Eval.Map1Vertex3 = state;
  248.      break;
  249.       case GL_MAP1_VERTEX_4:
  250.      CC.Eval.Map1Vertex4 = state;
  251.      break;
  252.       case GL_MAP2_COLOR_4:
  253.      CC.Eval.Map2Color4 = state;
  254.      break;
  255.       case GL_MAP2_INDEX:
  256.      CC.Eval.Map2Index = state;
  257.      break;
  258.       case GL_MAP2_NORMAL:
  259.      CC.Eval.Map2Normal = state;
  260.      break;
  261.       case GL_MAP2_TEXTURE_COORD_1: 
  262.      CC.Eval.Map2TextureCoord1 = state;
  263.      break;
  264.       case GL_MAP2_TEXTURE_COORD_2:
  265.      CC.Eval.Map2TextureCoord2 = state;
  266.      break;
  267.       case GL_MAP2_TEXTURE_COORD_3:
  268.      CC.Eval.Map2TextureCoord3 = state;
  269.      break;
  270.       case GL_MAP2_TEXTURE_COORD_4:
  271.      CC.Eval.Map2TextureCoord4 = state;
  272.      break;
  273.       case GL_MAP2_VERTEX_3:
  274.      CC.Eval.Map2Vertex3 = state;
  275.      break;
  276.       case GL_MAP2_VERTEX_4:
  277.      CC.Eval.Map2Vertex4 = state;
  278.      break;
  279.       case GL_NORMALIZE:
  280.      CC.Transform.Normalize = state;
  281.      break;
  282.       case GL_POINT_SMOOTH:
  283.      if (CC.Point.SmoothFlag!=state) {
  284.             CC.Point.SmoothFlag = state;
  285.             CC.NewState = GL_TRUE;
  286.          }
  287.      break;
  288.       case GL_POLYGON_SMOOTH:
  289.      if (CC.Polygon.SmoothFlag!=state) {
  290.             CC.Polygon.SmoothFlag = state;
  291.             CC.NewState = GL_TRUE;
  292.          }
  293.      break;
  294.       case GL_POLYGON_STIPPLE:
  295.      if (CC.Polygon.StippleFlag!=state) {
  296.             CC.Polygon.StippleFlag = state;
  297.             CC.NewState = GL_TRUE;
  298.          }
  299.      break;
  300.       case GL_POLYGON_OFFSET_EXT:
  301.          if (CC.Polygon.OffsetEnabled!=state) {
  302.             CC.Polygon.OffsetEnabled = state;
  303.             CC.NewState = GL_TRUE;
  304.          }
  305.          break;
  306.       case GL_SCISSOR_TEST:
  307.          if (CC.Scissor.Enabled!=state) {
  308.             CC.Scissor.Enabled = state;
  309.             CC.NewState = GL_TRUE;
  310.          }
  311.      break;
  312.       case GL_STENCIL_TEST:
  313.      if (CC.Stencil.Enabled!=state) {
  314.             CC.Stencil.Enabled = state;
  315.             CC.NewState = GL_TRUE;
  316.          }
  317.      if (state && !CC.StencilBuffer) {
  318.         /* need to allocate a stencil buffer now */
  319.         gl_alloc_stencil_buffer();
  320.      }
  321.      break;
  322.       case GL_TEXTURE_1D:
  323.          if (CC.RGBAflag) {
  324.             /* texturing only works in RGB mode */
  325.             if (state) {
  326.                CC.Texture.Enabled |= 1;
  327.             }
  328.             else {
  329.                CC.Texture.Enabled &= 2;
  330.             }
  331.             CC.NewState = GL_TRUE;
  332.          }
  333.      break;
  334.       case GL_TEXTURE_2D:
  335.          if (CC.RGBAflag) {
  336.             /* texturing only works in RGB mode */
  337.             if (state) {
  338.                CC.Texture.Enabled |= 2;
  339.             }
  340.             else {
  341.                CC.Texture.Enabled &= 1;
  342.             }
  343.             CC.NewState = GL_TRUE;
  344.          }
  345.      break;
  346.       case GL_TEXTURE_GEN_Q:
  347.          if (state) {
  348.             CC.Texture.TexGenEnabled |= Q_BIT;
  349.          }
  350.          else {
  351.             CC.Texture.TexGenEnabled &= ~Q_BIT;
  352.          }
  353.          CC.NewState = GL_TRUE;
  354.      break;
  355.       case GL_TEXTURE_GEN_R:
  356.          if (state) {
  357.             CC.Texture.TexGenEnabled |= R_BIT;
  358.          }
  359.          else {
  360.             CC.Texture.TexGenEnabled &= ~R_BIT;
  361.          }
  362.          CC.NewState = GL_TRUE;
  363.      break;
  364.       case GL_TEXTURE_GEN_S:
  365.      if (state) {
  366.             CC.Texture.TexGenEnabled |= S_BIT;
  367.          }
  368.          else {
  369.             CC.Texture.TexGenEnabled &= ~S_BIT;
  370.          }
  371.          CC.NewState = GL_TRUE;
  372.      break;
  373.       case GL_TEXTURE_GEN_T:
  374.          if (state) {
  375.             CC.Texture.TexGenEnabled |= T_BIT;
  376.          }
  377.          else {
  378.             CC.Texture.TexGenEnabled &= ~T_BIT;
  379.          }
  380.          CC.NewState = GL_TRUE;
  381.      break;
  382.       default:
  383.      if (state) {
  384.         gl_error( GL_INVALID_ENUM, "glEnable" );
  385.      }
  386.      else {
  387.         gl_error( GL_INVALID_ENUM, "glDisable" );
  388.      }
  389.          break;
  390.    }
  391. }
  392.  
  393.  
  394.  
  395.  
  396. void glEnable( GLenum cap )
  397. {
  398.    if (CC.CompileFlag) {
  399.       gl_save_enable( cap );
  400.    }
  401.    if (CC.ExecuteFlag) {
  402.       gl_enable( cap, GL_TRUE );
  403.    }
  404. }
  405.  
  406.  
  407.  
  408. void glDisable( GLenum cap )
  409. {
  410.    if (CC.CompileFlag) {
  411.       gl_save_disable( cap );
  412.    }
  413.    if (CC.ExecuteFlag) {
  414.       gl_enable( cap, GL_FALSE );
  415.    }
  416. }
  417.  
  418.  
  419.  
  420. GLboolean glIsEnabled( GLenum cap )
  421. {
  422.    switch (cap) {
  423.       case GL_ALPHA_TEST:
  424.          return CC.Color.AlphaEnabled;
  425.       case GL_AUTO_NORMAL:
  426.      return CC.Eval.AutoNormal;
  427.       case GL_BLEND:
  428.          return CC.Color.BlendEnabled;
  429.       case GL_CLIP_PLANE0:
  430.       case GL_CLIP_PLANE1:
  431.       case GL_CLIP_PLANE2:
  432.       case GL_CLIP_PLANE3:
  433.       case GL_CLIP_PLANE4:
  434.       case GL_CLIP_PLANE5:
  435.      return CC.Transform.ClipEnabled[cap-GL_CLIP_PLANE0];
  436.       case GL_COLOR_MATERIAL:
  437.      return CC.Light.ColorMaterialEnabled;
  438.       case GL_CULL_FACE:
  439.          return CC.Polygon.CullFlag;
  440.       case GL_DEPTH_TEST:
  441.          return CC.Depth.Test;
  442.       case GL_DITHER:
  443.      return CC.Color.DitherFlag;
  444.       case GL_FOG:
  445.      return CC.Fog.Enabled;
  446.       case GL_LIGHTING:
  447.          return CC.Light.Enabled;
  448.       case GL_LIGHT0:
  449.       case GL_LIGHT1:
  450.       case GL_LIGHT2:
  451.       case GL_LIGHT3:
  452.       case GL_LIGHT4:
  453.       case GL_LIGHT5:
  454.       case GL_LIGHT6:
  455.       case GL_LIGHT7:
  456.          return CC.Light.Light[cap-GL_LIGHT0].Enabled;
  457.       case GL_LINE_SMOOTH:
  458.      return CC.Line.SmoothFlag;
  459.       case GL_LINE_STIPPLE:
  460.      return CC.Line.StippleFlag;
  461.       case GL_LOGIC_OP:
  462.      return CC.Color.LogicOpEnabled;
  463.       case GL_MAP1_COLOR_4:
  464.      return CC.Eval.Map1Color4;
  465.       case GL_MAP1_INDEX:
  466.      return CC.Eval.Map1Index;
  467.       case GL_MAP1_NORMAL:
  468.      return CC.Eval.Map1Normal;
  469.       case GL_MAP1_TEXTURE_COORD_1:
  470.      return CC.Eval.Map1TextureCoord1;
  471.       case GL_MAP1_TEXTURE_COORD_2:
  472.      return CC.Eval.Map1TextureCoord2;
  473.       case GL_MAP1_TEXTURE_COORD_3:
  474.      return CC.Eval.Map1TextureCoord3;
  475.       case GL_MAP1_TEXTURE_COORD_4:
  476.      return CC.Eval.Map1TextureCoord4;
  477.       case GL_MAP1_VERTEX_3:
  478.      return CC.Eval.Map1Vertex3;
  479.       case GL_MAP1_VERTEX_4:
  480.      return CC.Eval.Map1Vertex4;
  481.       case GL_MAP2_COLOR_4:
  482.      return CC.Eval.Map2Color4;
  483.       case GL_MAP2_INDEX:
  484.      return CC.Eval.Map2Index;
  485.       case GL_MAP2_NORMAL:
  486.      return CC.Eval.Map2Normal;
  487.       case GL_MAP2_TEXTURE_COORD_1: 
  488.      return CC.Eval.Map2TextureCoord1;
  489.       case GL_MAP2_TEXTURE_COORD_2:
  490.      return CC.Eval.Map2TextureCoord2;
  491.       case GL_MAP2_TEXTURE_COORD_3:
  492.      return CC.Eval.Map2TextureCoord3;
  493.       case GL_MAP2_TEXTURE_COORD_4:
  494.      return CC.Eval.Map2TextureCoord4;
  495.       case GL_MAP2_VERTEX_3:
  496.      return CC.Eval.Map2Vertex3;
  497.       case GL_MAP2_VERTEX_4:
  498.      return CC.Eval.Map2Vertex4;
  499.       case GL_NORMALIZE:
  500.      return CC.Transform.Normalize;
  501.       case GL_POINT_SMOOTH:
  502.      return CC.Point.SmoothFlag;
  503.       case GL_POLYGON_SMOOTH:
  504.      return CC.Polygon.SmoothFlag;
  505.       case GL_POLYGON_STIPPLE:
  506.      return CC.Polygon.StippleFlag;
  507.       case GL_POLYGON_OFFSET_EXT:
  508.      return CC.Polygon.OffsetEnabled;
  509.       case GL_SCISSOR_TEST:
  510.      return CC.Scissor.Enabled;
  511.       case GL_STENCIL_TEST:
  512.      return CC.Stencil.Enabled;
  513.       case GL_TEXTURE_1D:
  514.      return (CC.Texture.Enabled & 1) ? GL_TRUE : GL_FALSE;
  515.       case GL_TEXTURE_2D:
  516.      return (CC.Texture.Enabled & 2) ? GL_TRUE : GL_FALSE;
  517.       case GL_TEXTURE_GEN_Q:
  518.      return (CC.Texture.TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE;
  519.       case GL_TEXTURE_GEN_R:
  520.      return (CC.Texture.TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE;
  521.       case GL_TEXTURE_GEN_S:
  522.      return (CC.Texture.TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE;
  523.       case GL_TEXTURE_GEN_T:
  524.      return (CC.Texture.TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE;
  525.       default:
  526.      gl_error( GL_INVALID_ENUM, "glIsEnabled" );
  527.      return GL_FALSE;
  528.    }
  529. }
  530.  
  531.